TI-Basic Basic Fortran Pascal Prolog Delphi Visual Basic Java

Elementos básicos de C

La función main

#include 

main(){
	declaraciones
	instrucciones
}

Entrada y salida de datos

La función puts (Put String) manda a la salida estándar la cadena que se le pasa por parámetro.

#include 
main(){
	puts("Mi primer programa en C");
}

#include 
main(){
	char cadena[10] = "Hola";
	puts(cadena);
}

Caracteres y cadenas

Una cadena es un arreglo de caracteres:

	H o l a \b
	0 1 2 3 4  5 6 7 8 9

El cuarto caracter es un final de cadena.

#include 
main(){
	char cadena[] = "Hola";
	puts(cadena);
}

Así la cadena solo tendrá 5 elementos:

	H o l a \b
	0 1 2 3 4

La función gets (Get String) lee una cadena de la entrada estándar. En este programa la entrada no debe tener más de 10 caracteres:

#include 
main(){
	char cadena[10];
	gets(cadena);
	puts(cadena);
}

printf (Print File) manda la salida a un flujo de datos, en este caso la salida estándar:

#include 
main(){
	prinf("Otro ejemplo");
}

Se imprime la cadena "Otro ejemplo" y deja el cursor en la misma línea.

#include 
main(){
	prinf("Otro ejemplo\n");
}

Se imprime la cadena "Otro ejemplo" y deja el cursor en la siguiente línea. El caracter "\" es el caracter de "escape". En seguida del mismo la "n" representa nueva línea (new line).

Con printf se puede obtener una salida con formato:

#include 
main(){
	char cadena[] = "Hola";
	printf("%s", cadena);
}

En este caso %s representa un valor de cadena (string) que será sustituído con el segundo parámetro de printf.

#include 
main(){
	char cadena1[]="Hola", cadena2[]=este es un mensaje";
	printf("%s %s", cadena1, cadena2);
}

La salida sería:

Hola este es un mensaje

Por otra parte:

#include 
main(){
	char cadena1[]="Hola", cadena2[]=este es un mensaje";
	printf("%s\n%s", cadena1, cadena2);
}

Entonces la salida sería:

Hola
este es un mensaje

Identificadores enteros y reales

#include 
main(){
	int a = 5,b = 2,c;

	c = a + b;
	printf("%d = %d + %d\n", c, a, b);
	c = a - b;
	printf("%d = %d - %d\n", c, a, b);
	c = a * b;
	printf("%d = %d * %d\n", c, a, b);
	c = a / b;
	printf("%d = %d / %d\n", c, a, b);
}

Aquí se obtiene la suma, la resta, la multiplicación y la división de 5 y 2. %d es el formato para valores enteros (decimal). %f es el formato para valores reales (float).

La división entre números enteros obtiene un valor entero, si alguno de los valores es real entonces se obtiene un valor real.

# include 
main(){
	float r, per, are, vol;
	float pi=3.1416;

	printf("Dame el valor del radio: ");
	scanf("%f",&r);

	per=pi*r;	/*Se calcula el perímetro del círculo*/
	are=pi*r*r;
	vol=(3.0/4)*pi*r*r*r;

	printf("El valor del perímetro es %f\n", per);
	printf("El valor del área es %f\n", are);
	printf("El valor del volumen es %f\n", vol);
}

Constantes y comentarios

Arreglos

Estructuras de control de programación

La estructura for

	for(inicialización; condición; incremento/decremento){
		instrucciones
	}

#include 
main(){
	char s[10];
	int i;

	gets(s);
	for(i=0; s[i]!=' '; i++);
	printf("La posición del primer blanco es %d", i);
}

Expresiones de relación y lógicas

	Símbolo		Significado

	   >		Mayor que
	   <		Menor que
	   >=		Mayor o igual que
	   <=		Menor o igual que
	   !=		Diferente
	   ==		Igual a

Operadores lógicos:

	y	&&
	o	||
	no	!

i++ Es un operador unitario (se aplica sobre un operando). Incrementa en 1 el valor de la variable. i++ devuelve el valor de i y luego lo incrementa. ++i incrementa el valor de i y luego lo devuelve. También existe el de decremento i--.

#include 
main(){
	char A;
	for (A=´x´; A!='A'; )
		A = getche();	//Lee un caracter hasta que se lea un 'A'
}

getche() Obtiene un caracter de la entrada y realiza un "eco" a la salida. getch() no realiza el eco.

	for(;;){
		//Estas instrucciones se ejecutarán indefinidamente
	}

#include 
main(){
	int x[10], y[10], w[10], i;

	for (i=0; i<=9; i++)	/* Lectura del vector x */
		scanf("%d", &x[i]);

	for (i=0; i<=9; i++)	/* Lectura del vector y */
		scanf("%d", &y[i]);

	for (i=0; i<=9; i++)	/* Suma de vectores */
		w[i] = x[i] + y[i];

	for (i=0; i<=9; i++)	/* Impresión del vector w */
		printf("%d\n", w[i]);
}

También se pueden leer alternadamente los valores de los vectores:

	for (i=0; i<=9; i++) {
		scanf("%d", &x[i]);
		scanf("%d", &y[i]);
	}

o también así:

	for (i=0; i<=9; i++)
		scanf("%d %d", &x[i], &y[i]);

El caracter 'a' es distinto a la cadena "a". "%c" es el formato de salida para un caracter.

#include 
main(){
	char cadena[6] = "ABCDEF";
	int i=5;

	for( ; i>=0; i-- )
		printf("%c", cadena[i]);
}

Es equivalente a:

#include 
main(){
	char cadena[6] = "ABCDEF", x;
	int i;

	for( i=5; i>=3; i-- ){
		x = cadena[i];
		cadena[i] = cadena[5-i];
		cadena[5-1] = x;
	}
	puts(cadena);
}

#include 
main(){
	int A[3][3], B[3][3], C[3][3];
	int i, k;

	/*Lectura de los datos de la matriz A*/
	for (i=0; i<=2; i++)
		for (k=0; k<=2; k++)
			scanf("%d", &A[i][k]);

	/*Impresión de la matriz A*/
	for (i=0; i<=2; i++){
		for (k=0; k<=2; k++)
			printf("%d", A[i][k]);
		printf("\n");
	}
}

Se podría realizar la suma de dos matrices así:

	for (i=0; i<=2; i++){
		for (k=0; k<=2; k++)
			C[i][k] = A[i][k] + B[i][k];

Mientras que el producto sería:

	for (i=0; i<=2; i++)
		for (j=0; j<=2; j++){
			for (k=0; k<=2; k++)
				acumulado = A[i][k] * B[j][i] + acumulado;
			c[i][j] = acumulado;
			acumulado = 0;
		}

Este programa realiza varias operaciones con matrices.

Este programa calcula el promedio de n valores:

#include 
main(){
	int n, cont;
	float suma=prom=act=0;

	printf("Dame el número de datos: ");
	scanf("%d", &n);
	for (cont = 1; cont<=n; cont++){
		printf("\nDame el valor número %d", cont)
		scanf("%f", &act);
		suma = suma + act;
	}
	prom = suma / n;
	printf("\nEl promedio es %f", prom);
}

Este programa calcula A*x = y, donde "A" es una matriz y "x" y "y" son vectores:

#include 
main(){
	float A[9][9], x[9], y[9], acum;
	int i, j, k, acum = 0;

	printf("\nDame la matriz A:\n);
	for (i=0; i<=9; i++)
		for (j=0; j<=9; j++)
			scanf("%f", &A[i][j]);

	printf("\nDame el vector x:\n);
	for (i=0; i<=9; i++)
		scanf("%f", &x[i]);

	for (i=0; i<=9; i++){
		for (j=0; j<=9; j++)
			acum = A[i][j] * x [j] + acum
		y[i] = acum;
		acum = 0;
	}

	printf("\nPresenta el vector y:\n);
	for (i=0; i<=9; i++)
		printf("y[%d] = %f", &i, &y[i]);
}

Este programa pone en orden inverso los valores de una matriz:

#include 
main(){
	float A[9][9], temp;
	int i, j, k;

	printf("\nDame la matriz A:\n);
	for (i=0; i<=9; i++)
		for (j=0; j<=9; j++)
			scanf("%f", &A[i][j]);

	for (i=0; i<=9; i++)
		for (j=0; j<=4; j++){
			temp = A[i][j];
			A[i][j] = A[i][9-j];
			A[i][9-j] = temp;
		}
}

Este programa obtiene el producto escalar de dos vectores:

#include 
main(){
	float x[4], y[4], punto;
	int i;

	printf("\nDame el vector x:\n");
	for (i=0; i<=4; i++)
		scanf("%f", &x[i]);

	printf("\nDame el vector y:\n");
	for (i=0; i<=4; i++)
		scanf("%f", &y[i]);

	punto = 0;

	for (i=0; i<=4; i++)
		punto = punto + x[i]*y[i];

	printf("\nEl producto punto es %f.\n", punto);	
}

La estructura if-else

	if condición
		instrucción(es)
	else
		instrucción

	if condición
		instrucción

	if condición_A
		instrucción_A
	else if condición_B
		instrucción_B
	.
	 .
	  .
	else
		instrucción_Z

A y B son enteros, imprimir el menor o ambos si son iguales:

#include 
main(){
	int A=5; B=6;

	if ( A < B )
		printf("%d", A);
	else if ( A == B )
		printf("%d %d", A, B);
	else /* A > B */
		printf("%d", B);
}

A, B y C son enteros; imprimir el menor; si dos son iguales y menores al tercero se imprimen; si los tres son iguales se imprimen.

#include 
main(){
	int A=3; B=8; C=3;

	if ( A < B )
		if ( A < C)
			printf("%d", A);
		else if ( A == C )
			printf("%d %d", A, C);
		else /* A > C */
			printf("%d", C);
	else if ( A == B )
		if ( A < C )
			printf("%d %d", A, B);
		else if ( A == C )
			printf("%d %d %d", A, B, C);
		else /* A > C */
			printf("%d", C);
	else /* A > B */
		if ( B < C)
			printf("%d", B);
		else if ( B == C )
			printf("%d %d", B, C);
		else /* B > C */
			printf("%d", C);
}

Este programa junta dos vectores:

#include 
main(){
	int A[]={3, 7, 8, 12, 23, 31, 1000},
	    B[]={7, 8, 11, 15, 100},
	    C[12], i, j, k, dimA=7, dimB=5;
	i = j = k = 0;

	for ( ; (i<=dimA)&&(j<=dimB); )
		if ( A[i] < B[j] )
			C[k++] = A[i++];
		else if ( A[i] == B[j] ) {
			C[k++] = A[i++];
			C[k++] = B[j++];
		}
		else /* Ai > Bj */
			C[k++] = B[j++];

	fot (i=0; i<=9; i++)
		printf("%d", C[i]);
}

#include 
main(){
	int A={}, B={}, C={},
	    D[100], i = j = k = l = 0, dimA, dimB, dimC;

	for ( ; i<=dimA && j<=dimB && k<=dimC; )
		if ( A[i] < B[j] )
			if ( A[i] < C[k] )
				D[l++] = A[i++];
			else if if ( A[i] == C[k] ){
				D[l++] = A[i++];
				D[l++] = C[k++];
			}
			else /*Ai > Ck*/
				D[l++] = C[k++];
		else if ( A[i] == B[j] )
			if ( A[i] < C[k] ){
				D[l++] = A[i++];
				D[l++] = B[j++];
			}
			else if ( A[i] == C[k] ){
				D[l++] = A[i++];
				D[l++] = B[j++];
				D[l++] = C[k++];
			}
			else /* Ai < Ck */
				D[l++] = C[k++];
		else /* Ai > Bj */
			if ( B[j] < C[k] )
				D[l++] = B[j++];
			else if ( B[j] == C[k] ){
				D[l++] = B[j++];
				D[l++] = C[k++];
			}
			else /* Bj > Ck*/
				D[l++] = C[k++];
}

La estructura while

Si la condición se cumple, entonces se ejecuta el ciclo:

	while condición
		instrucción

Es equivalente a:

	for ( ; condición; )
		instrucción

La estructura do-while

En esta variación de while, la instrucción se ejecuta al menos una vez.

	do
		instrucción
	while condición

La estructura switch

	switch condición {
		case eti_1: instrucciones_A
			    break;
		case eti_2: instrucciones_B
			    break;
		.
		 .
		  .
		case eti_n: instrucciones_n
			    break;
		default: instrucciones
	}

gotoxy posiciona el cursor en las coordenadas que se le pasen como parámetro. La pantalla tiene 80 caracteres a lo largo (x) y 25 a los alto (y).

#include 
main(){
	char cara;

	gotoxy(39,10);
	printf("1.- Opción 1");
	gotoxy(39,11);
	printf("2.- Opción 2");
	gotoxy(39,12);
	printf("3.- Opción 3");
	gotoxy(39,13);
	printf("4.- Salida");
	gotoxy(39,15);
	printf("Seleccione una opción ");
	do {
		cara = getche();
		gotoxy(39,17);
		switch(cara){
			case '1':	printf("Fué opción 1);
					break;
			case '2':	printf("Fué opción 2);
					break;
			case '3':	printf("Fué opción 3);
					break;
			default :	cara = 'S';
		}
	} while (cara != 'S');
}

Supongamos que tenemos la matriz A con estos elementos:

		|0 0 0 0|
		|0 7 0 0|
	A = 	|0 0 3 0|
		|0 1 0 0|

Se podría representar en forma de vector así:

		w = | 1 1 7 2 2 3 3 1 1 4 4 1000 |

Se leería así: En el renglón 1, columna 1 hay un 7; en el renglón 2, columna 2 hay un 3; en el renglón 3, columna 1 hay un 1. La matriz tiene 4 renglones y 4 columnas.

El siguiente programa podría obtener el valor de algún elemento de la matriz:

#include 
main(){
	int w[] = { 1, 1, 7, 2, 2, 3, 3, 1, 1, 4, 4, 1000 }, x, y, cont=0;

	printf("Dame las coordenadas x, y: ");
	scanf("%d %d", &x, &y);

	do {
		if ((w[cont] < x) || ((w[cont]==x && w[cont+1] < y)))
			cont = cont + 3; // o también cont+=3;
		else if ((w[cont] == x) && (w[cont+1] == y))
			printf ("El valor es %d", w[cont + 2]);
		else if (((w[cont] == x) && (w[cont+1] > y)) || (w[cont] > x))
			printf ("El valor es cero");
	} while (w[cont+2] != 1000);
}

Primer examen parcial:

		|0 0 0 0|		|0  3 4 0|		|0 3 4 0|
		|0 7 0 0|	+	|0 -7 0 0|	= 	|0 0 0 0|
		|0 0 3 1|		|0  0 0 0|		|0 0 3 2|
		|0 1 0 0|		|0  0 0 0|		|0 1 0 0|

Realizar la suma en forma de vectores. Programa aquí

Funciones

La forma de una función

nombre (argumentos){
	declaraciones
	instrucciones
}

#include 

suma(int x[10], int y[10], int w[10]){
	int i;
	for (i=0; i<=9; i++)
		w[i] = x[i] + y[i];
}

lee(int x[10]);		//Solo se declaran, luego se implementan
imprime(int x[10]);

main(){
	int A[10], B[10], C[10];
	lee(A);		//No se podría hacer la llamada si no estuviera declarada
	lee(B);
	suma(A, B, C);
	imprime(A);	
	imprime(B);
	imprime(C);
}

int i;			//Esta variable es "global"

lee(int x[10]){
	for (i=0; i<=9; i++)
		scanf("%d", &x[i]);
}

imprime(int x[10]){
	for (i=0; i<=9; i++)
		printf("%d", &x[i]);
}

Por default sólo se mandan los valores de los parámetros a las funciones. Si se quiere pasar la dirección de la variable se deben usar apuntadores:

#include 

cambia(int *a, int *b){
	int temp

	temp = *a;
	*a = *b;
	*b = temp;
}

main(){
	int x = 5, y = 7;

	printf("%d %d", x, y);
	cambia(&x, &y);
	printf("%d %d", x, y);
}

Una excepción es cuando se pasan arreglos, ya que C los trata como apuntadores como en el primer ejemplo.

Una función puede devolver un valor con la instrucción return:

#include 

int suma(int a, int b){
	return a + b;
}

main(){
	int x = 5, y = 12;
	printf("%d", suma(x,y));
}

Una función puede tener varios return, pero todos deben regresar valores del mismo tipo y se debe tener en cuenta que la ejecución de la función se detendrá con el primero que encuentre.

Ejemplo de operaciones con matrices

El prototipo de una función

Clases de almacenamiento

Macros

Estructuras, uniones y apuntadores

Apuntadores a datos simples

C trata a las cadenas como un apuntador constante.

#include 
main(){
	char cadena[]="Hola";
	char *p;

	p = cadena;
	puts(p);
}

Sin embargo hay que tener en cuenta que cadena=p no es válido, p es solo una variable que "apunta" al inicio de la cadena.

    
	p	cadena: H o l a \b
	|	cadena[ 0 1 2 3 4 ]
	---------------->

#include 
main(){
	int a=5, b=2, c;
	char cad[] = "El resultado es ";
	char *p;

	c = a + b;
	p = cadena;

	printf("%s %d\n", p, c);
}

#include 
main(){
	int *a, *b, *c;
	int x=5, y=6, z;

	a = &x;
	b = &y;
	c = &z;

	z = *a + *b;
	printf("%d", *c);
}

La instrucción *a = *b equivale a x = y. Mientras que c = a equivale a c = &x.

#include 
main(){
	int x=5, y=8, z;
	int *a = &x, *b = &y, *c = &z;

	*c = x + y;
	printf("%d", z);
}

# include 
main(){
	float rad, per, are, vol;
	float *a=&rad, *b=&per, *c=&are, *d=&vol;
	float pi=3.1416;

	printf("\nDame el valor del radio: ");
	scanf("%f",&*a);

	*b=pi*(*a);
	*c=*b*(*a);
	*d=(3.0/4)*(*c)*(*a);

	printf("El valor del perímetro es %f\n",*b);
	printf("El valor del  rea es %f\n",*c);
	printf("El valor del volumen es %f\n",*d);
}

Apuntadores a datos compuestos

Considere el siguiente código:

	int A[10], B[10], C[10];
	int *p, *q, *r;

	p = A; q = B; r = C;

es equivalente a:

	int A[10], B[10], C[10];
	int *p=A, *q=B, *r=C;

Así mismo los siguientes ciclos for realizan la misma operación:

	for (i=0; i<=9; i++)
		*(r+i) = *(p+i) + *(q+i);

	for (i=0; i<=9; i++)
		(*r)++ = (*p)++ + (*q)++;

	for (i=0; i<=9; i++)
		r[i] = p[i] + q[i];

Otro ejemplo:

# include 

suma(int x[10],int y[10],int w[10]){
	int i;
	for(i=0;i<=9;i++)
		w[i]=x[i]+y[i];
}

lee(int x[10]);

imprime(int x[10]);

main(){
	int A[10],B[10],C[10];
	int *p = A, *q = B, *r = C;

	lee(p);
	lee(q);
	suma(p,q,r);
	imprime(p);
	imprime(q);
	imprime(r);
}

int i;

lee(int *x){
	printf("\n\n Dame 10 valores para este vector: \n");
	for(i=0;i<=9;i++)
		scanf("%d",&(*x++)); //o también scanf("%d",&x[i]); o scanf("%d",&*(x+i));
}

imprime(int *x){
	printf("\n");
	for(i=0;i<=9;i++)
		printf("%d ",(*x++)); //o también printf("%d ",x[i]); o printf("%d ",*(x+i));
}

int *x es un apuntador a un valor entero.
int *x[10] es un arreglo de 10 apuntadores a valores enteros.
int (*w)[10] es un apuntador a un arreglo de 10 enteros. Con int y[10] se podría hacer w=y.

Apuntadores a funciones

int fn(int y); Es una función que solicita entero y regresa entero.
int *fn(int y); Es una función que solicita entero y regresa un apuntador entero.
int (*fn)(int w); Es un apuntador con un argumento entero y regresa un valor entero.

#include 

main(){
	int C[5];
	int *A[5],*B[5];

	lee(A);
	lee(B);
	suma(A,B,C);
	imprime(C);
}

lee(int *x[5]){
	int i;

	printf("\n\nDame 5 valores para este vector:\n");
	for(i=0;i<=4;i++)
		scanf("%d",&*x[i]);
}

suma(int *x[5],int *y[5],int z[5]){
	int i;

	for(i=0;i<=4;i++)
		z[i]=*x[i]+*y[i];  //igual a: *(z+i) = *(x+i) + *(y+i);
}

imprime(int x[5]){
	int i;

	printf("\n\nLa suma de ambos vectores es:\n");
	for(i=0;i<=4;i++)
		printf("%d ",x[i]);
}

Arreglos dinámicos

#include 

int *asignamemo(int dimX){
	return (int *)malloc(sizeof(int)*dimX);

	//(int *)	Hace que la función regrese un apuntador
	//malloc	Reserva una cantidad determinada de memoria
	//sizeof	Regresa el número de bytes necesarios para almacenar un tipo
	//		de variable, en este caso enteros.
}

int i;
dimA = 15;

suma(int x[],int y[],int w[]){
	for(i=0;i < dimA;i++)
		w[i]=x[i]+y[i];
}

leevector(int x[]){
	printf("\n\nDame %d valores para este vector:\n",dimA);
	for(i=0;i < dimA;i++)
		scanf("%d",&x[i]);
	}

impvector(int x[]){
	printf("\n\nLa suma de los dos vectores es:\n");
	for(i=0;i < dimA;i++)
		printf("%d ",x[i]);
}

main(){
	int *p,*q,*r;

	p=asignamemo(dimA);
	q=asignamemo(dimA);
	r=asignamemo(dimA);

	leevector(p);
	leevector(q);

	suma(p,q,r);

	impvector(p);
	impvector(q);
	impvector(r);
}

Si imaginamos la memoria como un vector de bytes, los programas y las variables que usa se "cargan" del principio hacia el final. En cambio, las variables dinámicas (malloc) se asignan del final hacia el principio.

# include 

int ix,kx,i,k;

int *asignamemo(int dimX){
	return(int *)malloc(sizeof(int)*dimX);
}

suma(int *x,int *y,int *w){
	for(i=0;i < ix*kx;i++)
		w[i]=x[i]+y[i];
}

leemat(int *x){
	printf("\n\nDame una matriz de %dx%d:\n",ix,kx);
	for(i=0;i < ix*kx;i++)
		scanf("%d",&x[i]);
}

impmat(int *x){
	int j=0;

	printf("\nLa suma de las matrices es:\n");
	for(i=0;i < ix;i++){
		for(k=0;k < kx;k++)
			printf("%d ",x[j++]); // o también: printf("%d ",x[i*ix+k]);
		printf("\n");
	}
}

main(){
	int *p,*q,*r;
	ix = kx = 10;

	p=asignamemo(ix*kx);
	q=asignamemo(ix*kx);
	r=asignamemo(ix*kx);

	leemat(p);
	leemat(q);
	suma(p,q,r);
	impmat(p);
	impmat(q);
	impmat(r);
}

Operaciones con apuntadores

Estructuras y uniones

	struct empleado{
		char nombre[30];
		int categoria;
		float salario;
	}

La definición "struct empleado A, B, C;" hace que las variables A, B y C tengan la estructura definida para empleado. Se le pueden hacer asignaciones a los elementos de la estructura con el operador punto (.) así: "A.categoria = 2; C.salario = 70.30;"

También se pueden definir apuntadores a variables de este tipo: "struct empleado *p, *q, *r;" después de la declaración se pueden hacer asignaciones como: "p=&A; q=&B; r=&C;". Para poder hacer asignaciones a los elementos del apuntador de una estructura se usa el operador (->) así: "r->categoria = A.categoria;"

Dadas las siguientes instrucciones:

	struct empleado x[10], *p;

	p=x;
	p->categoria = 7;
	(p+3)->categoria = 8;
	p[2].categoria = 18;
	x[1].categoria = 0;

Se tendría:

	x[0].categoria = 7
	x[1].categoria = 0
	x[2].categoria = 18
	x[3].categoria = 8

También se puede asignar memoria dinámicamente para las estructuras:

	struct empleado *asignamemo(){
		return (struct empleado *)malloc(sizeof(struct empleado));
	}

Así se pueden crear variables que no existieran previamente: "p = asignamemo();".

		_ _ _
	   p--->|_|_|_|		Localidades de memoria "nueva"
		| | |->salario
		| |--->categoria
		|----->nombre

También es posible crear estructuras que contengan apuntadores a estructuras, incluso del mismo tipo que ellas mismas:

	struct nodo{
		char dato;
		struct nodo *sig;
	}

	struct nodo *asignamemo(){
		return (struct nodo *)malloc(sizeof(struct nodo));
	}

	struct nodo *p, *q, *r

	p=asignamemo();
	q=asignamemo();

	p->dato = 'A';
	q->dato = 'B';

	p->sig = q;
	q->sig = null;

		_ _        _ _
	   p--->|A|_|----->|B|_|
		      q--->|

Con el siguiente fragmento de código se puede "llenar" una estructura recursiva:

	p=asignamemo();
	r=p;
	for (i=1; i<=3; i++){
		q=asignamemo();
		scanf("%c", &(q->dato));
		r->sig = q;
		r=q;
	}

Se puede "vaciar" una estructura recursiva así:

	r=p;
	while (r!=null){
		printf("%c", r->dato);
		r=r->sig;
	}

Para "agregar" un valor:

Para "quitar" un valor:

Se puede hacer aritmética entera sin límite usando apuntadores:

	     |     |     |     |
	12345 67891 01112 13141 51617
	+             854 32853 91145
	                 |     |
	-----------------------------
	12345 67891 01966 45995 42762

	      |<------------------------------------------------------------|
	p-->|-1| |-->|51617| |-->|13141| |-->|01112| |-->|67891| |-->|12345| |

	      |<----------------------------------|
	q-->|-1| |-->|91145| |-->|32853| |-->|854| |

acarreo=0;
s=t=r;
p=p->sig;
q=q->sig;

while ((q->dato!=1) && (p->dato!=-1)){
	rdo = q->dato+p->dato+acarreo;
	acarreo = rdo / 100000;		//División entera
	rdo = rdo % 100000;		//Residuo de la div. entera

	s = asignamemo();
	s->dato = rdo;
	s->sig = t->sig;
	t-sig = s;
	t = s;
	p = p->sig;
	q = q->sig;
}

if (p->dato==-1)
	temp = q;
else
	temp = p;

while (temp->dato==-1){
	rdo = temp->dato+acarreo;
	acarreo = rdo / 100000;
	rdo = rdo % 100000;
	s = asignamemo();
	s->dato = rdo;
	s->sig = t->sig;
	t->sig = s;
	t = s;
	temp = temp->sig;
}

if (acarreo!=0){
	s = asignamemo();
	s->dato=1;
	s->sig = t->sig;
	t->sig = s;
}

main(){
	char valor1[25], valor2[25];
	struct nodo *p, *q, *r;

	LecturaValor(valor1);
	LecturaValor(valor2);

	convierte(valor1, p);
	convierte(valor2, q);

	suma(p, q, r);

	imprime(p);
	imprime(q);
	imprime(r);
}

Tercer examen parcial.

Segundo examen parcial: Dadas las siguientes definiciones:

	(a,b) + (c,d) = (a+c, b+d)
	(a,b) - (c,d) = (a-c, b-d)
	(a,b) * (c,d) = (a*c, b*d)
	(a,b) / (c,d) = (a/c, b/d)

Realice un programa que las implemente haciendo uso de variables dinámicas. Cada función debe devolver un apuntador a una variable dinámica. Las variables dinámicas deben ser estructuras.

#include 

struct pareja{
	int x;
	int y;
}

struct pareja *asignamemo(){
	return (struct pareja *)malloc(sizeof(struct pareja));
}

struct pareja *suma(struct pareja *p, struct pareja *q){
	struct pareja *r;

	r=asignamemo();
	r->x = (p->x)+(q->x);
	r->y = (p->y)+(q->y);
	return r;
}

struct pareja *resta(struct pareja *p, struct pareja *q){
	struct pareja *r;

	r=asignamemo();
	r->x = (p->x)-(q->x);
	r->y = (p->y)-(q->y);
	return r;
}

struct pareja *multi(struct pareja *p, struct pareja *q){
	struct pareja *r;

	r=asignamemo();
	r->x = (p->x)*(q->x);
	r->y = (p->y)*(q->y);
	return r;
}

struct pareja *divi(struct pareja *p, struct pareja *q){
	struct pareja *r;

	r=asignamemo();
	if ((q->x)!=0)
		r->x = (p->x)/(q->x);
	else
		r->x = 9999;
	if ((q->y)!=0)
		r->y = (p->y)/(q->y);
	else
		r->y = 9999;
	return r;
}

lee (struct pareja *p){
	printf("\nDame un par de enteros:\n");
	scanf("%d %d", &(p->x), &(p->y));
}

imprime (struct pareja *p){
	printf("(%d, %d)", p->x, p->y);
}

main(){
	struct pareja *a, *b, *c;

	a=asignamemo();
	b=asignamemo();
	c=asignamemo();

	lee(a);
	lee(b);

	printf("\n");
	imprime(a);
	printf("+");
	imprime(b);
	printf("=");
	*c=*suma(a,b);
	imprime(c);

	printf("\n");
	imprime(a);
	printf("-");
	imprime(b);
	printf("=");
	*c=*resta(a,b);
	imprime(c);

	printf("\n");
	imprime(a);
	printf("*");
	imprime(b);
	printf("=");
	*c=*multi(a,b);
	imprime(c);

	printf("\n");
	imprime(a);
	printf("/");
	imprime(b);
	printf("=");
	*c=*divi(a,b);
	imprime(c);
}

Archivos

Como abrir y cerrar un archivo

Dentro de un programa en C un archivo es leído a través de un apuntador. Al escribir o al leer el apuntador del archivo, este avanza. Se asocia el apuntador al archivo mediante la instrucción fopen:

	ap_archivo = fopen(nombre_archivo, tipo_acceso);

nombre_archivo se refiere al nombre del archivo que tiene dentro del sistema operativo. El tipo de acceso puede ser: lectura, escritura o lectura/escritura. Una vez terminadas las operaciones que se deban realizar con el archivo se debe de cerrar.

	fclose(ap_archivo);

Proceso de un archivo de datos

Se usan las instrucciones fwrite y fread para escribir y leer datos del archivo:

	fwrite(&x, sizeof(reg), 1, ap_archivo);
	fread(&x, sizeof(reg), 1, ap_archivo);

x es un registro de tipo reg. El 1 representa que se guardará un solo registro. Si x fuera un arreglo de 5 registros de tipo reg, entonces se podrían guardar los 5 de una sola vez cambiando el 1 por un 5.

Un programa completo que usa archivos se encuentra aquí.

Cuarto examen parcial aquí.

Proyecto

struct regtra{
	int llave;
	char nombre[12];
	float sueldo;
	int codigo;
}

struct regmae{
	int llave;
	char nombre[12];
	float sueldo;
}

main(){
	
}

Proyecto final aquí.

Programas ejemplos:

Apuntadores y arreglos 1
Apuntadores y arreglos 2
Apuntadores y arreglos 3
Apuntadores y arreglos 4
Archivos
Auxiliar
Big Copy
Elecciones
Experimento 1
Funciones 1
Funciones 2
Ifs
Programa 1
Programa 2
Programa 3
Programa 4
Programa 5
Proyecto
Prueba
Switch
TextCom